package com.weilan.ark3.controller;

import com.weilan.ark3.buffer.DataArray;
import com.weilan.ark3.buffer.MsgQueue;
import com.weilan.ark3.common.GlobalParam;
import com.weilan.ark3.entity.ControlDto;
import com.weilan.ark3.entity.ParamDto;
import com.weilan.ark3.entity.SocDto;
import com.weilan.ark3.sqlite.SQLiteParamUtils;
import com.weilan.ark3.utils.ArrayUtils;
import com.weilan.ark3.utils.SocUtils;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RestController;

import static com.weilan.ark3.buffer.OverallSituation.OverallEMSData;

@RestController
@CrossOrigin
public class BackupController {
    //备电模式
    public static void backupMode() {
        ControlDto controlDto = new ControlDto();
        //获得的SOC_L  SOC_H  备电充电功率
        ParamDto param = SQLiteParamUtils.query();
        int soc_h = Integer.parseInt(param.getSoc_h());
        int soc_l = Integer.parseInt(param.getSoc_l());
        //System.out.println("高soc"+soc_h);
        int back_power = Integer.parseInt(param.getBack_power());
        int deviceNum = param.getDeviceNum();
        //if (DataArray.data != null && DataArray.data.length > 0 && DataArray2.data.length > 0 && DataArray2.data != null) {
        if (DataArray.data != null && DataArray.data.length > 0) {
            //系统状态(RO)
            short sys_sta = DataArray.data[100];
            //PCS1状态
            short sys_mod = DataArray.data[127];
            //状态控制（RW的启停）
            short ctl_sta = DataArray.data[301];
            //获得系统的SOC
            short soc = DataArray.data[248];
            //获得当前系统的功率
            short sys_power = DataArray.data[302];
            //并网时执行(并网或并离网)
            if (sys_mod == 2) {
                if (sys_sta != 3) {
                    //判断是否启动(避免0功率保护) 当前系统状态为停机，并且控制状态为停止（下发启动）
                    if (sys_sta == 1 && ctl_sta == 2) {
                        //给系统下发启动
                        controlDto.setSlaveId(GlobalParam.guangbo);
                        controlDto.setAddress(GlobalParam.onoff);
                        controlDto.setValue(GlobalParam.start);
                        MsgQueue.writeToControlTcp(controlDto);
                        //系统0功率保护状态
                    } else if ((sys_sta == 1 && ctl_sta == 6) || (sys_sta == 2 && ctl_sta == 6)) {
                        //判断当前的SOC在什么区间
                        //1.当soc<soc_l  下发备电充电功率
                        if (soc < soc_l) {
                            //做一个功率校验，减少功率持续下发的数量

                            controlDto.setSlaveId(GlobalParam.guangbo);
                            controlDto.setAddress(GlobalParam.power);
                            controlDto.setValue(back_power);
                            MsgQueue.writeToControlTcp(controlDto);
                            //下发禁充的标志
                            //1.1 给功率接收下发的地方一个标志（禁止充放的标志）

                            GlobalParam.bansign = 1;
                            //2.当soc_l < soc < soc_h   可执行任何功率
                            //2.1 取消标志
                            //2.2
                        } else if (soc_l < soc && soc < soc_h) {
                            GlobalParam.bansign = 0;
                        }
                        //3.当 soc >= soc_h 只能下发放电，不能充电
                        //3.1 禁止下发充电功率 ，可以进行放电
                        //判断当前为充电还是放电 ，如果是充电，下发0功率
                        else if (soc > soc_h) {
                            GlobalParam.bansign = 2;
                            if (sys_power < 0) {
                                controlDto.setSlaveId(GlobalParam.guangbo);
                                controlDto.setAddress(GlobalParam.power);
                                controlDto.setValue(GlobalParam.zeroP);
                                MsgQueue.writeToControlTcp(controlDto);
                            }
                        }
                    }
                }
            }
        }
    }

    //备电模式——SOC区间控制模式
    public static void backupModeSoc() {
        OverallEMSData = DataArray.slaveDataMap.get(1);
        ControlDto controlDto = new ControlDto();
        //获得的SOC_L  SOC_H  备电充电功率
        ParamDto param = SQLiteParamUtils.query();
        //int soc_h = Integer.parseInt(param.getSoc_h());
        //int soc_l = Integer.parseInt(param.getSoc_l());
        //System.out.println("高soc"+soc_h);
        int back_power = Integer.parseInt(param.getBack_power());//备电充电功率
        int deviceNum = param.getDeviceNum();//设备数量

        //获得SOC参数
        SocDto socDto = SocUtils.query();
        int bcp_soc = socDto.getBcp_soc();//备电soc

        //if (DataArray.data != null && DataArray.data.length > 0 && DataArray2.data.length > 0 && DataArray2.data != null) {
        if (DataArray.data != null && DataArray.data.length > 0) {
            //系统状态(RO)
            short sys_sta = OverallEMSData[1];
            //PCS1状态
            short sys_mod = OverallEMSData[127];
            //状态控制（RW的启停）
            short ctl_sta = OverallEMSData[61];
            //获得系统的SOC
            short soc = OverallEMSData[26];
            //获得当前系统的功率
            //short sys_power = OverallEMSData[302];
            //并网时执行(并网或并离网)
            //if (sys_mod == 2) {
                if (sys_sta != 3) {
                    //判断是否启动(避免0功率保护) 当前系统状态为停机，并且控制状态为停止（下发启动）
                    if (sys_sta == 1 && ctl_sta == 2) {
                        //给系统下发启动
                        controlDto.setSlaveId(GlobalParam.guangbo);
                        controlDto.setAddress(GlobalParam.onoff);
                        controlDto.setValue(GlobalParam.start);
                        MsgQueue.writeToControlTcp(controlDto);
                        //系统0功率保护状态
                    } else if ((sys_sta == 1 && ctl_sta == 6) || (sys_sta == 2 && ctl_sta == 6)) {
                        //主要用于切换模式的时候降功率为0
                        if (GlobalParam.backZero == 0) {
                            controlDto.setSlaveId(GlobalParam.guangbo);
                            controlDto.setAddress(GlobalParam.power);
                            controlDto.setValue(0);
                            MsgQueue.writeToControlTcp(controlDto);
                            GlobalParam.backZero = 1;
                            GlobalParam.fengguZero = 0;
                            GlobalParam.pvZero = 0;
                        }
                        //判断当前的SOC在什么区间
                        //1.当soc<soc_l  下发备电充电功率
                        if (soc < bcp_soc) {
                            //做一个功率校验，减少功率持续下发的数量
                            //使用功率分配
                            int power = ArrayUtils.MinPower(back_power, deviceNum);

                            controlDto.setSlaveId(GlobalParam.guangbo);
                            controlDto.setAddress(GlobalParam.power);
                            controlDto.setValue(power);
                            MsgQueue.writeToControlTcp(controlDto);
                            //下发禁充的标志
                            //1.1 给功率接收下发的地方一个标志（禁止充放的标志）
                            GlobalParam.bansign = 1;
                            //2.当soc_l < soc < soc_h   可执行任何功率
                            //2.1 取消标志
                            //2.2
                            //} else if (soc_l < soc && soc < soc_h) {
                        } else if (bcp_soc < soc) {
                            GlobalParam.bansign = 0;
                        }
                        //3.当 soc >= soc_h 只能下发放电，不能充电
                        //3.1 禁止下发充电功率 ，可以进行放电
                        //判断当前为充电还是放电 ，如果是充电，下发0功率
//                        else if (soc > soc_h) {
//                            GlobalParam.bansign = 2;
//                            if (sys_power < 0) {
//                                controlDto.setSlaveId(GlobalParam.guangbo);
//                                controlDto.setAddress(GlobalParam.power);
//                                controlDto.setValue(GlobalParam.zeroP);
//                                MsgQueue.writeToControlTcp(controlDto);
//                            }
//                        }
                    }
                }
            }
        }
    }
//}